#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
将指定模型的参数JSON文件转换为Excel格式
使用方法: python to_excel.py model=<模型名>
例如: python to_excel.py model=puma
"""

import sys
import json
import os
import pandas as pd
from typing import Dict, Any, List, Union

def print_usage():
    """打印使用说明"""
    print("使用方法: python to_excel.py model=<模型名>")
    print("例如: python to_excel.py model=puma")
    print("这将读取 <模型名>_param.json 文件并输出为 <模型名>_param.xlsx")

def parse_arguments():
    """解析命令行参数"""
    if len(sys.argv) < 2:
        print("错误: 缺少参数")
        print_usage()
        sys.exit(1)
    
    # 解析 model=xxx 格式的参数
    model_name = None
    for arg in sys.argv[1:]:
        if arg.startswith("model="):
            model_name = arg.split("=", 1)[1]
            break
    
    if not model_name:
        print("错误: 需要指定 model 参数")
        print_usage()
        sys.exit(1)
    
    return model_name

def load_json_file(file_path: str) -> Dict[str, Any]:
    """加载JSON文件"""
    if not os.path.exists(file_path):
        print(f"错误: 文件 {file_path} 不存在")
        sys.exit(1)
    
    try:
        with open(file_path, 'r', encoding='utf-8') as f:
            return json.load(f)
    except json.JSONDecodeError as e:
        print(f"错误: JSON文件格式无效 - {e}")
        sys.exit(1)
    except Exception as e:
        print(f"错误: 无法读取文件 {file_path} - {e}")
        sys.exit(1)

def flatten_dict(data: Dict[str, Any], parent_key: str = '', sep: str = '.') -> Dict[str, Any]:
    """将嵌套字典展平"""
    items = []
    for k, v in data.items():
        new_key = f"{parent_key}{sep}{k}" if parent_key else k
        if isinstance(v, dict):
            items.extend(flatten_dict(v, new_key, sep=sep).items())
        elif isinstance(v, list):
            # 对于列表，我们将其转换为字符串
            items.append((new_key, str(v)))
        else:
            items.append((new_key, v))
    return dict(items)

def process_json_to_dataframe(data: Any) -> pd.DataFrame:
    """将JSON数据转换为DataFrame"""
    all_dataframes = []
    
    # 如果数据是列表，处理每个元素
    if isinstance(data, list):
        for i, item in enumerate(data):
            if isinstance(item, dict):
                df = process_single_model(item, i)
                all_dataframes.append(df)
    elif isinstance(data, dict):
        df = process_single_model(data, 0)
        all_dataframes.append(df)
    else:
        # 简单数据类型
        df = pd.DataFrame([{'参数名': 'value', '参数值': str(data)}])
        all_dataframes.append(df)
    
    # 合并所有DataFrame
    if all_dataframes:
        return pd.concat(all_dataframes, ignore_index=True)
    else:
        return pd.DataFrame(columns=['参数名', '参数值'])

def process_single_model(model_data: Dict[str, Any], model_index: int) -> pd.DataFrame:
    """处理单个模型的数据"""
    rows = []
    
    # 加载参数名称映射
    param_mapping = {}
    try:
        with open('paramset_en_cn.json', 'r', encoding='utf-8') as f:
            param_mapping = json.load(f)
    except Exception as e:
        print(f"警告: 无法加载参数映射文件 - {e}")
    
    # 处理模型基本信息
    for key, value in model_data.items():
        if key == 'paramSet' and isinstance(value, list):
            # 处理参数集合
            for param in value:
                if isinstance(param, dict):
                    param_name_en = param.get('param_name_en', '')
                    param_name_cn = param.get('param_name_cn', '')
                    param_value = param.get('param_value', '')
                    
                    # 如果原始数据中没有中文名，尝试从映射中获取
                    if not param_name_cn and param_name_en in param_mapping:
                        param_name_cn = param_mapping[param_name_en]
                    
                    # 优先使用中文名，如果没有则使用英文名
                    display_name = param_name_cn if param_name_cn else param_name_en
                    
                    rows.append({
                        '分类': '技术参数',
                        '参数名(中文)': param_name_cn,
                        '参数名(英文)': param_name_en,
                        '参数值': param_value
                    })
        elif key == 'colorSet' and isinstance(value, list):
            # 处理颜色信息
            color_list = ', '.join(value)
            rows.append({
                '分类': '颜色选项',
                '参数名(中文)': '可选颜色',
                '参数名(英文)': 'Available Colors',
                '参数值': color_list
            })
        elif key == 'model_co_name':
            # 处理动力系统标签
            rows.append({
                '分类': '基本信息',
                '参数名(中文)': '动力系统',
                '参数名(英文)': 'Powertrain',
                '参数值': str(value)
            })
        else:
            # 处理其他基本信息
            rows.append({
                '分类': '基本信息',
                '参数名(中文)': key,
                '参数名(英文)': key,
                '参数值': str(value) if not isinstance(value, (dict, list)) else str(value)
            })
    
    return pd.DataFrame(rows)

def save_to_excel(df: pd.DataFrame, output_file: str):
    """保存DataFrame到Excel文件"""
    try:
        from openpyxl.styles import PatternFill, Font
        
        with pd.ExcelWriter(output_file, engine='openpyxl') as writer:
            df.to_excel(writer, sheet_name='参数列表', index=False)
            
            # 获取工作表
            worksheet = writer.sheets['参数列表']
            
            # 调整列宽
            worksheet.column_dimensions['A'].width = 15  # 分类
            worksheet.column_dimensions['B'].width = 40  # 参数名(中文)
            worksheet.column_dimensions['C'].width = 40  # 参数名(英文)
            worksheet.column_dimensions['D'].width = 30  # 参数值
            
            # 设置样式 - 黄色底色和粗体字体
            yellow_fill = PatternFill(start_color="FFFF00", end_color="FFFF00", fill_type="solid")
            bold_font = Font(bold=True)
            
            # 为基本信息行（model名称行）设置格式
            for row_idx, row in df.iterrows():
                if row['分类'] == '基本信息':
                    excel_row = row_idx + 2  # +2 因为Excel从1开始计数，且有表头
                    # 为整行设置黄色底色和粗体
                    for col in ['A', 'B', 'C', 'D']:
                        cell = worksheet[f'{col}{excel_row}']
                        cell.fill = yellow_fill
                        cell.font = bold_font
            
        print(f"成功输出文件: {output_file}")
        print(f"总共处理了 {len(df)} 个参数")
        
    except Exception as e:
        print(f"错误: 无法保存Excel文件 - {e}")
        sys.exit(1)

def main():
    """主函数"""
    # 解析参数
    model_name = parse_arguments()
    
    # 构造文件路径
    input_file = f"{model_name}_param.json"
    output_file = f"{model_name}_param.xlsx"
    
    print(f"正在处理模型: {model_name}")
    print(f"输入文件: {input_file}")
    print(f"输出文件: {output_file}")
    
    # 加载JSON文件
    json_data = load_json_file(input_file)
    
    # 转换为DataFrame
    df = process_json_to_dataframe(json_data)
    
    # 保存为Excel
    save_to_excel(df, output_file)

if __name__ == "__main__":
    main()
